package com.doubao.device.config;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.doubao.common.result.Result;
import com.doubao.device.dto.SmartDeviceDTO;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.LinkedHashMap;
import java.util.List;

/**
 * 结果处理工具类 - 用于处理微服务间调用时的类型转换问题
 */
@Slf4j
@Component
public class ResultHandlerUtils {

    private final ObjectMapper objectMapper;

    public ResultHandlerUtils(ObjectMapper objectMapper) {
        this.objectMapper = objectMapper;
    }

    /**
     * 通用结果处理方法 - 适用于任何返回类型
     *
     * @param serviceResult 服务方法返回的结果
     * @param dataType 期望的数据类型Class
     * @param <T> 泛型参数
     * @return 处理后的Result对象
     */
    @SuppressWarnings("unchecked")
    public <T> Result<T> handleServiceResult(Object serviceResult, Class<T> dataType) {
        try {
            // 检查结果类型
            if (serviceResult instanceof Result) {
                // 如果已经是Result类型，直接返回
                return (Result<T>) serviceResult;
            } else if (serviceResult instanceof LinkedHashMap) {
                // 如果是Map，转换为Result对象
                LinkedHashMap<String, Object> map = (LinkedHashMap<String, Object>) serviceResult;

                // 获取基本信息
                Integer code = (Integer) map.get("code");
                String message = (String) map.get("message");
                Boolean success = (Boolean) map.get("success");

                // 转换data字段
                if (map.get("data") != null && success != null && success) {
                    T data = objectMapper.convertValue(map.get("data"), dataType);
                    return Result.success(data, message != null ? message : "操作成功");
                } else if (success != null && success) {
                    return Result.success(null, message != null ? message : "操作成功");
                } else {
                    // 失败结果
                    if (code != null) {
                        return Result.failed(code, message != null ? message : "操作失败");
                    } else {
                        return Result.failed(message != null ? message : "操作失败");
                    }
                }
            } else {
                // 其他情况，返回错误
                log.error("未预期的结果类型: {}", serviceResult != null ? serviceResult.getClass().getName() : "null");
                return Result.failed("数据类型错误");
            }
        } catch (Exception e) {
            log.error("处理服务结果异常", e);
            return Result.failed("处理结果失败: " + e.getMessage());
        }
    }

    /**
     * 通用结果处理方法 - 适用于泛型结果
     *
     * @param serviceResult 服务方法返回的结果
     * @param valueType 值类型Class
     * @param parameterClasses 泛型参数类型Class数组
     * @param <T> 泛型参数
     * @return 处理后的Result对象
     */
    @SuppressWarnings("unchecked")
    public <T> Result<T> handleGenericResult(Object serviceResult, Class<?> valueType, Class<?>... parameterClasses) {
        try {
            // 检查结果类型
            if (serviceResult instanceof Result) {
                // 如果已经是Result类型，直接返回
                return (Result<T>) serviceResult;
            } else if (serviceResult instanceof LinkedHashMap) {
                // 如果是Map，转换为Result对象
                LinkedHashMap<String, Object> map = (LinkedHashMap<String, Object>) serviceResult;

                // 获取基本信息
                Integer code = (Integer) map.get("code");
                String message = (String) map.get("message");
                Boolean success = (Boolean) map.get("success");

                // 构建泛型参数类型
                JavaType javaType = objectMapper.getTypeFactory().constructParametricType(valueType, parameterClasses);

                // 转换data字段
                if (map.get("data") != null && success != null && success) {
                    T data = objectMapper.convertValue(map.get("data"), javaType);
                    return Result.success(data, message != null ? message : "操作成功");
                } else if (success != null && success) {
                    return Result.success(null, message != null ? message : "操作成功");
                } else {
                    // 失败结果
                    if (code != null) {
                        return Result.failed(code, message != null ? message : "操作失败");
                    } else {
                        return Result.failed(message != null ? message : "操作失败");
                    }
                }
            } else {
                // 其他情况，返回错误
                log.error("未预期的结果类型: {}", serviceResult != null ? serviceResult.getClass().getName() : "null");
                return Result.failed("数据类型错误");
            }
        } catch (Exception e) {
            log.error("处理泛型结果异常", e);
            return Result.failed("处理结果失败: " + e.getMessage());
        }
    }

    /**
     * 处理分页结果
     *
     * @param serviceResult 服务返回结果
     * @param pageType 页面类型
     * @param elementType 元素类型
     * @return 结果
     */
    @SuppressWarnings("unchecked")
    public <T> Result<IPage<T>> handlePageResult(Object serviceResult, Class<?> pageType, Class<T> elementType) {
        try {
            // 检查结果类型
            if (serviceResult instanceof Result) {
                // 如果已经是Result类型，直接返回
                return (Result<IPage<T>>) serviceResult;
            } else if (serviceResult instanceof LinkedHashMap) {
                // 如果是Map，转换为Result对象
                LinkedHashMap<String, Object> map = (LinkedHashMap<String, Object>) serviceResult;

                // 获取基本信息
                Integer code = (Integer) map.get("code");
                String message = (String) map.get("message");
                Boolean success = (Boolean) map.get("success");

                // 构建泛型类型
                JavaType pageJavaType = objectMapper.getTypeFactory().constructParametricType(
                        (Class<IPage>) pageType,
                        elementType);

                // 转换data字段
                if (map.get("data") != null && success != null && success) {
                    IPage<T> data = objectMapper.convertValue(map.get("data"), pageJavaType);
                    return Result.success(data, message != null ? message : "操作成功");
                } else if (success != null && success) {
                    return Result.success(null, message != null ? message : "操作成功");
                } else {
                    // 失败结果
                    if (code != null) {
                        return Result.failed(code, message != null ? message : "操作失败");
                    } else {
                        return Result.failed(message != null ? message : "操作失败");
                    }
                }
            } else {
                // 其他情况，返回错误
                log.error("未预期的结果类型: {}", serviceResult != null ? serviceResult.getClass().getName() : "null");
                return Result.failed("数据类型错误");
            }
        } catch (Exception e) {
            log.error("处理分页结果异常", e);
            return Result.failed("处理结果失败: " + e.getMessage());
        }
    }

    /**
     * 通用结果处理方法 - 适用于列表结果
     *
     * @param serviceResult 服务方法返回的结果
     * @param elementType 元素类型Class
     * @param <T> 元素类型
     * @return 处理后的Result对象
     */
    @SuppressWarnings("unchecked")
    public <T> Result<List<T>> handleListResult(Object serviceResult, Class<T> elementType) {
        try {
            // 使用Jackson的TypeFactory处理复杂的泛型类型
            JavaType listType = objectMapper.getTypeFactory().constructCollectionType(List.class, elementType);

            if (serviceResult instanceof Result) {
                return (Result<List<T>>) serviceResult;
            } else if (serviceResult instanceof LinkedHashMap) {
                LinkedHashMap<String, Object> map = (LinkedHashMap<String, Object>) serviceResult;

                // 获取基本信息
                Integer code = (Integer) map.get("code");
                String message = (String) map.get("message");
                Boolean success = (Boolean) map.get("success");

                // 转换data字段
                if (map.get("data") != null && success != null && success) {
                    List<T> data = objectMapper.convertValue(map.get("data"), listType);
                    return Result.success(data, message != null ? message : "操作成功");
                } else if (success != null && success) {
                    return Result.success(null, message != null ? message : "操作成功");
                } else {
                    // 失败结果
                    if (code != null) {
                        return Result.failed(code, message != null ? message : "操作失败");
                    } else {
                        return Result.failed(message != null ? message : "操作失败");
                    }
                }
            } else {
                // 其他情况，返回错误
                log.error("未预期的结果类型: {}", serviceResult != null ? serviceResult.getClass().getName() : "null");
                return Result.failed("数据类型错误");
            }
        } catch (Exception e) {
            log.error("处理列表结果异常", e);
            return Result.failed("处理结果失败: " + e.getMessage());
        }
    }
}